package com.chenjun.common.util;

import java.math.BigDecimal;
import java.util.Arrays;

import com.alibaba.fastjson.JSONObject;

/**
 * 数字格式化函数
 * 
 * @Title: NumberUtil
 * @date 2015年2月13日 下午3:44:16
 * @version V1.0
 */
public final class NumberUtil {
    private NumberUtil() {
    }

    /**
     * 精确的加法运算.
     */
    public static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).doubleValue();
    }

    /**
     * 
     * 精确的减法运算.
     * 
     * @param v1
     *            被减数
     * @param v2
     *            减数
     */
    public static double subtract(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算.
     */
    public static double multiply(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算，并对运算结果截位.
     * 
     * @param scale
     *            运算结果小数后精确的位数
     */
    public static double multiply(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                            "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP)
                        .doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算.
     * 
     * @see #divide(double, double, int)
     */
    public static double divide(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.divide(b2).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算. 由scale参数指定精度，以后的数字四舍五入.
     * 
     * @param v1
     *            被除数
     * @param v2
     *            除数
     * @param scale
     *            表示表示需要精确到小数点以后几位
     */
    public static double divide(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                            "The scale must be a positive integer or zero");
        }

        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理.
     * 
     * @param v
     *            需要四舍五入的数字
     * @param scale
     *            小数点后保留几位
     */
    public static double round(double v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                            "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }


    /*将int转为低字节在前，高字节在后的byte数组 
    b[0] = 11111111(0xff) & 01100001 
    b[1] = 11111111(0xff) & (n >> 8)00000000 
    b[2] = 11111111(0xff) & (n >> 8)00000000 
    b[3] = 11111111(0xff) & (n >> 8)00000000 
    */ 
	public static int byteArrayToInt(byte[] sizeBytes) {
        if(sizeBytes.length!=4){    
            return -1;    
        }    
        return (int) ((((sizeBytes[3] & 0xff) << 24)      
                   | ((sizeBytes[2] & 0xff) << 16)      
                   | ((sizeBytes[1] & 0xff) << 8)  
                   | ((sizeBytes[0] & 0xff) << 0)));  
	}
	
	public static void main(String[] args) {
		byte [] s={73, 0, 0, 0};
		System.out.println(byteArrayToInt(s));
		System.out.println(Arrays.toString(IntToByteArray(73)));
	}
	
	//将低字节在前转为int，高字节在后的byte数组(与IntToByteArray1想对应)  
	public static byte[] IntToByteArray(int n) {    
        byte[] b = new byte[4];    
        b[0] = (byte) (n & 0xff);    
        b[1] = (byte) (n >> 8 & 0xff);    
        b[2] = (byte) (n >> 16 & 0xff);    
        b[3] = (byte) (n >> 24 & 0xff);    
        return b;    
}
}
